home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 PPC / Demo / pdist / FSProxy.py < prev    next >
Text File  |  1996-05-19  |  7KB  |  323 lines
  1. """File System Proxy.
  2.  
  3. Provide an OS-neutral view on a file system, locally or remotely.
  4. The functionality is geared towards implementing some sort of
  5. rdist-like utility between a Mac and a UNIX system.
  6.  
  7. The module defines three classes:
  8.  
  9. FSProxyLocal  -- used for local access
  10. FSProxyServer -- used on the server side of remote access
  11. FSProxyClient -- used on the client side of remote access
  12.  
  13. The remote classes are instantiated with an IP address and an optional
  14. verbosity flag.
  15. """
  16.  
  17. import server
  18. import client
  19. import md5
  20. import os
  21. import fnmatch
  22. from stat import *
  23. import time
  24. import fnmatch
  25.  
  26. if os.name == 'mac':
  27.     import macfs
  28.     maxnamelen = 31
  29. else:
  30.     macfs = None
  31.     maxnamelen = 255
  32.  
  33. skipnames = (os.curdir, os.pardir)
  34.  
  35.  
  36. class FSProxyLocal:
  37.     
  38.     def __init__(self):
  39.         self._dirstack = []
  40.         self._ignore = ['*.pyc'] + self._readignore()
  41.     
  42.     def _close(self):
  43.         while self._dirstack:
  44.             self.back()
  45.     
  46.     def _readignore(self):
  47.         file = self._hide('ignore')
  48.         try:
  49.             f = open(file)
  50.         except IOError:
  51.             file = self._hide('synctree.ignorefiles')
  52.             try:
  53.                 f = open(file)
  54.             except IOError:
  55.                 return []
  56.         ignore = []
  57.         while 1:
  58.             line = f.readline()
  59.             if not line: break
  60.             if line[-1] == '\n': line = line[:-1]
  61.             ignore.append(line)
  62.         f.close()
  63.         return ignore
  64.     
  65.     def _hidden(self, name):
  66.         if os.name == 'mac':
  67.             return name[0] == '(' and name[-1] == ')'
  68.         else:
  69.             return name[0] == '.'
  70.     
  71.     def _hide(self, name):
  72.         if os.name == 'mac':
  73.             return '(%s)' % name
  74.         else:
  75.             return '.%s' % name
  76.     
  77.     def visible(self, name):
  78.         if len(name) > maxnamelen: return 0
  79.         if name[-1] == '~': return 0
  80.         if name in skipnames: return 0
  81.         if self._hidden(name): return 0
  82.         head, tail = os.path.split(name)
  83.         if head or not tail: return 0
  84.         if macfs:
  85.             if os.path.exists(name) and not os.path.isdir(name):
  86.                 try:
  87.                     fs = macfs.FSSpec(name)
  88.                     c, t = fs.GetCreatorType()
  89.                     if t != 'TEXT': return 0
  90.                 except macfs.error, msg:
  91.                     print "***", name, msg
  92.                     return 0
  93.         else:
  94.             if os.path.islink(name): return 0
  95.             if '\0' in open(name, 'rb').read(512): return 0
  96.         for ign in self._ignore:
  97.             if fnmatch.fnmatch(name, ign): return 0
  98.         return 1
  99.     
  100.     def check(self, name):
  101.         if not self.visible(name):
  102.             raise os.error, "protected name %s" % repr(name)
  103.     
  104.     def checkfile(self, name):
  105.         self.check(name)
  106.         if not os.path.isfile(name):
  107.             raise os.error, "not a plain file %s" % repr(name)
  108.     
  109.     def pwd(self):
  110.         return os.getcwd()
  111.     
  112.     def cd(self, name):
  113.         self.check(name)
  114.         save = os.getcwd(), self._ignore
  115.         os.chdir(name)
  116.         self._dirstack.append(save)
  117.         self._ignore = self._ignore + self._readignore()
  118.     
  119.     def back(self):
  120.         if not self._dirstack:
  121.             raise os.error, "empty directory stack"
  122.         dir, ignore = self._dirstack[-1]
  123.         os.chdir(dir)
  124.         del self._dirstack[-1]
  125.         self._ignore = ignore
  126.     
  127.     def _filter(self, files, pat = None):
  128.         if pat:
  129.             def keep(name, pat = pat):
  130.                 return fnmatch.fnmatch(name, pat)
  131.             files = filter(keep, files)
  132.         files = filter(self.visible, files)
  133.         files.sort()
  134.         return files
  135.     
  136.     def list(self, pat = None):
  137.         files = os.listdir(os.curdir)
  138.         return self._filter(files, pat)
  139.     
  140.     def listfiles(self, pat = None):
  141.         files = os.listdir(os.curdir)
  142.         files = filter(os.path.isfile, files)
  143.         return self._filter(files, pat)
  144.     
  145.     def listsubdirs(self, pat = None):
  146.         files = os.listdir(os.curdir)
  147.         files = filter(os.path.isdir, files)
  148.         return self._filter(files, pat)
  149.     
  150.     def exists(self, name):
  151.         return self.visible(name) and os.path.exists(name)
  152.     
  153.     def isdir(self, name):
  154.         return self.visible(name) and os.path.isdir(name)
  155.     
  156.     def islink(self, name):
  157.         return self.visible(name) and os.path.islink(name)
  158.     
  159.     def isfile(self, name):
  160.         return self.visible(name) and os.path.isfile(name)
  161.     
  162.     def sum(self, name):
  163.         self.checkfile(name)
  164.         BUFFERSIZE = 1024*8
  165.         f = open(name)
  166.         sum = md5.new()
  167.         while 1:
  168.             buffer = f.read(BUFFERSIZE)
  169.             if not buffer:
  170.                 break
  171.             sum.update(buffer)
  172.         return sum.digest()
  173.     
  174.     def size(self, name):
  175.         self.checkfile(name)
  176.         return os.stat(name)[ST_SIZE]
  177.     
  178.     def mtime(self, name):
  179.         self.checkfile(name)
  180.         return time.localtime(os.stat(name)[ST_MTIME])
  181.     
  182.     def stat(self, name):
  183.         self.checkfile(name)
  184.         size = os.stat(name)[ST_SIZE]
  185.         mtime = time.localtime(os.stat(name)[ST_MTIME])
  186.         return size, mtime
  187.     
  188.     def info(self, name):
  189.         sum = self.sum(name)
  190.         size = os.stat(name)[ST_SIZE]
  191.         mtime = time.localtime(os.stat(name)[ST_MTIME])
  192.         return sum, size, mtime
  193.     
  194.     def _list(self, function, list):
  195.         if list is None:
  196.             list = self.listfiles()
  197.         res = []
  198.         for name in list:
  199.             try:
  200.                 res.append((name, function(name)))
  201.             except (os.error, IOError):
  202.                 res.append((name, None))
  203.         return res
  204.     
  205.     def sumlist(self, list = None):
  206.         return self._list(self.sum, list)
  207.     
  208.     def statlist(self, list = None):
  209.         return self._list(self.stat, list)
  210.     
  211.     def mtimelist(self, list = None):
  212.         return self._list(self.mtime, list)
  213.     
  214.     def sizelist(self, list = None):
  215.         return self._list(self.size, list)
  216.     
  217.     def infolist(self, list = None):
  218.         return self._list(self.info, list)
  219.     
  220.     def _dict(self, function, list):
  221.         if list is None:
  222.             list = self.listfiles()
  223.         dict = {}
  224.         for name in list:
  225.             try:
  226.                 dict[name] = function(name)
  227.             except (os.error, IOError):
  228.                 pass
  229.         return dict
  230.     
  231.     def sumdict(self, list = None):
  232.         return self.dict(self.sum, list)
  233.     
  234.     def sizedict(self, list = None):
  235.         return self.dict(self.size, list)
  236.     
  237.     def mtimedict(self, list = None):
  238.         return self.dict(self.mtime, list)
  239.     
  240.     def statdict(self, list = None):
  241.         return self.dict(self.stat, list)
  242.     
  243.     def infodict(self, list = None):
  244.         return self._dict(self.info, list)
  245.     
  246.     def read(self, name, offset = 0, length = -1):
  247.         self.checkfile(name)
  248.         f = open(name)
  249.         f.seek(offset)
  250.         if length == 0:
  251.             data = ''
  252.         elif length < 0:
  253.             data = f.read()
  254.         else:
  255.             data = f.read(length)
  256.         f.close()
  257.         return data
  258.     
  259.     def create(self, name):
  260.         self.check(name)
  261.         if os.path.exists(name):
  262.             self.checkfile(name)
  263.             bname = name + '~'
  264.             try:
  265.                 os.unlink(bname)
  266.             except os.error:
  267.                 pass
  268.             os.rename(name, bname)
  269.         f = open(name, 'w')
  270.         f.close()
  271.     
  272.     def write(self, name, data, offset = 0):
  273.         self.checkfile(name)
  274.         f = open(name, 'r+')
  275.         f.seek(offset)
  276.         f.write(data)
  277.         f.close()
  278.     
  279.     def mkdir(self, name):
  280.         self.check(name)
  281.         os.mkdir(name, 0777)
  282.     
  283.     def rmdir(self, name):
  284.         self.check(name)
  285.         os.rmdir(name)
  286.  
  287.  
  288. class FSProxyServer(FSProxyLocal, server.Server):
  289.     
  290.     def __init__(self, address, verbose = server.VERBOSE):
  291.         FSProxyLocal.__init__(self)
  292.         server.Server.__init__(self, address, verbose)
  293.     
  294.     def _close(self):
  295.         server.Server._close(self)
  296.         FSProxyLocal._close(self)
  297.     
  298.     def _serve(self):
  299.         server.Server._serve(self)
  300.         # Retreat into start directory
  301.         while self._dirstack: self.back()
  302.  
  303.  
  304. class FSProxyClient(client.Client):
  305.     
  306.     def __init__(self, address, verbose = client.VERBOSE):
  307.         client.Client.__init__(self, address, verbose)
  308.  
  309.  
  310. def test():
  311.     import string
  312.     import sys
  313.     if sys.argv[1:]:
  314.         port = string.atoi(sys.argv[1])
  315.     else:
  316.         port = 4127
  317.     proxy = FSProxyServer(('', port))
  318.     proxy._serverloop()
  319.  
  320.  
  321. if __name__ == '__main__':
  322.     test()
  323.